A Development and Deployment Framework for Distributed Branch & Bound

Branch-and-bound intelligently searches the set of feasible solutions to a combinatorial optimization problem: It, in effect, proves that the optimal solution is found without necessarily examining all feasible solutions. The feasible solutions are not given. They can be generated from the problem description. However, doing so usually is computationally infeasible: The number of feasible solutions typically grows exponentially as a function of the size of the problem input. For example, the set of feasible tours in a symmetric Traveling Salesman Problem (TSP) of a complete graph with 23 nodes is 22!/2 or around 8 × 10 tours. The space of feasible solutions is progressively partitioned (branching), forming a search tree. Each tree node has a partial feasible solution. The node represents the set of feasible solutions that are extensions of its partial solution. For example, in a TSP branch and bound, a search tree node has a partial tour, representing the set of all tours that contain that partial tour. As branching continues (progresses down the problem tree), each search node has a more complete partial solution, and thus represents a smaller set of feasible solutions. For example, in a TSP branch and bound, a tree node’s children each represent an extension of the partial tour to a more complete tour (e.g., one additional city or one additional edge). As one progresses down the search tree, each node represents a larger partial tour. As the size of a partial tour increases, the number of full tours containing the partial tour clearly decreases. In traversing the search tree, we may come to a node that represents a set of feasible solutions, all of which are provably more costly than a feasible solution already found. When this occurs, we prune this node of the search tree: We discontinue further exploration of this set of feasible solutions. In the example of the TSP problem, the cost of any feasible tour that has a given partial tour surely can be bounded from below by the cost of the partial tour: the sum of the edge weights for the edges in the partial tour. (In our experiments, we use a Held-Karp lower bound, which is stronger but more computationally complex.) If the lower bound for a node is higher than the current upper bound (i.e., best known complete solution), then the cost of all complete solutions (e.g., tours) represented by the node is higher than a complete solution that is already known: The node is pruned. Please see Papadimitriou and Steiglitz [23] for a more complete discussion of branch-and-bound. Fig. 8 gives a basic, sequential branch-and-bound algorithm. The framework that we present here is designed for deployment in a distributed setting. Moreover, the framework supports adaptive parallelism: During the execution, the set of compute servers can grow (if new compute servers become available) or shrink (if compute servers become unavailable or fail): The branch and bound computation thus cannot assume a fixed number of compute servers. The branch and bound computation is decomposed into tasks, each of which is executed on a compute server: Each element of the active set (please see Fig. 8) is a task that, in principle, can be scheduled for execution on any compute server. Indeed, parallel efficiency requires load balancing of tasks among compute servers. This distributed setting implies the following compute server requirements: